home *** CD-ROM | disk | FTP | other *** search
/ Super PC 31 / Super PC 31 (Shareware).iso / spc / inter / speakf / fuente / connect.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  47.6 KB  |  1,534 lines
  1. /*
  2.  
  3.     Window procedure for connection MDI window
  4.     
  5. */
  6.  
  7. #include "netfone.h"
  8.  
  9. #define ASYNC_OUTPUT
  10.                             
  11. static struct {
  12.     char header[4];
  13.     unsigned short len, ilen;
  14.     soundbuf sbm;
  15. } mb = {{1, 2, 3, 4}};
  16. #define sb    mb.sbm
  17.  
  18. soundbuf ebuf;                            // Utility sound buffer
  19. static struct adpcm_state adpcm;      // ADPCM compression state
  20.  
  21. extern long outputPending;
  22. char blankit[] = "                                                              "
  23.                  "                                                              "
  24.                  "                                                              ";
  25.  
  26. /*  GSMCOMP  --  Compress the contents of a sound buffer using GSM.  */
  27.  
  28. static void gsmcomp(soundbuf *asb)
  29. {
  30.     gsm_signal src[160];
  31.     gsm_frame dst;
  32.     int i, j, l = 0;
  33.     char *dp = (asb->buffer.buffer_val) + sizeof(short);
  34.     long ldata = asb->buffer.buffer_len; 
  35.     
  36.     for (i = 0; i < ldata; i += 160) {
  37.         for (j = 0; j < 160; j++) {
  38.             if ((i + j) < asb->buffer.buffer_len) {
  39.                 src[j] = audio_u2s(asb->buffer.buffer_val[i + j]);
  40.             } else {
  41.                 src[j] = 0;
  42.             }
  43.         }
  44.         gsm_encode(gsmh, src, dst);
  45.         _fmemcpy(dp, dst, sizeof dst);
  46.         dp += sizeof dst;
  47.         l += sizeof dst;
  48.     }
  49.  
  50.     /* Hide original uncompressed buffer length in first 2 bytes of buffer. */
  51.     
  52.     *((short *) asb->buffer.buffer_val) = (short) ldata;
  53.     revshort((short *) asb->buffer.buffer_val);
  54.     asb->buffer.buffer_len = l + sizeof(short);
  55. }
  56.  
  57. /*    ADPCMCOMP  --  Compress the contents of a sound buffer using ADPCM.  */
  58.  
  59. static void adpcmcomp(soundbuf *asb)
  60. {
  61.     unsigned char *dp = (unsigned char *) asb->buffer.buffer_val;
  62.     struct adpcm_state istate;
  63.  
  64.     istate = adpcm;
  65.     adpcm_coder_u(dp, (char *) dp, (int) asb->buffer.buffer_len, &adpcm);
  66.     asb->buffer.buffer_len /= 2;
  67.  
  68.     /* Hide the ADPCM encoder state at the end of this buffer.
  69.        The shifting and anding makes the code byte-order
  70.        insensitive. */
  71.  
  72.     dp += asb->buffer.buffer_len;
  73.     *dp++ = ((unsigned int) istate.valprev) >> 8;
  74.     *dp++ = istate.valprev & 0xFF;
  75.     *dp = istate.index;
  76.     asb->buffer.buffer_len += 3;
  77. }
  78.  
  79. /*    LPCCOMP  --  Compress the contents of a sound buffer using LPC.  */
  80.  
  81. static void lpccomp(asb)
  82.   struct soundbuf *asb;
  83. {
  84.     int i, l = 0;
  85.     char *dp = ((char *) asb->buffer.buffer_val) + sizeof(short);
  86.     unsigned char *src = ((unsigned char *) asb->buffer.buffer_val);
  87.     lpcparams_t lp;
  88.  
  89.     asb->compression |= fCompLPC;
  90.     for (i = 0; i < asb->buffer.buffer_len; i += 180) {
  91.         lpc_analyze(src + i, &lp);
  92.         revshort(&(lp.period));
  93.         _fmemcpy(dp, &lp, sizeof lp);
  94.         dp += sizeof lp;
  95.         l += sizeof lp;
  96.     }
  97.  
  98.     // Hide original uncompressed buffer length in first 2 bytes of buffer.
  99.  
  100.     *((short *) asb->buffer.buffer_val) = (short) asb->buffer.buffer_len;
  101.     revshort((short *) asb->buffer.buffer_val);
  102.     asb->buffer.buffer_len = l + sizeof(short);
  103. }
  104.  
  105. /*  COMPRESS2X  --  Compress a sound buffer with Simple (discard every
  106.                     other sample) compression.  If you're doing both
  107.                     Simple and GSM compression, Simple compression must be
  108.                     done first.  */
  109.                     
  110. void compress2X(soundbuf *asb)
  111. {
  112.     LONG i;
  113.              
  114.     asb->buffer.buffer_len /= 2;
  115.     for (i = 1; i < asb->buffer.buffer_len; i++) {
  116.         asb->buffer.buffer_val[i] = asb->buffer.buffer_val[i * 2];
  117.     }
  118. }
  119.  
  120. //    WRITEOUTPUT  --  Transmit output buffer to destination
  121.  
  122. static int writeOutput(LPCLIENT_DATA d, LPSTR buf, int buflen)
  123. {
  124.     if (d->modemConnection) {
  125.         if (modemHandle != -1) {
  126.             unsigned short bcrc;
  127.             COMSTAT cs;
  128.             int wrl, err;
  129.         
  130.             mb.len = (unsigned short) buflen;
  131.             mb.ilen = ~mb.len;
  132.             revshort(&mb.len);
  133.             revshort(&mb.ilen);
  134.             bcrc = crc((LPSTR) &mb, buflen + 4 + 2 * sizeof(unsigned short));
  135.             revshort(&bcrc);
  136.             err = GetCommError(modemHandle, &cs);
  137.             if (err != 0) { 
  138.                 MsgBox(hwndMDIFrame, MB_ICONSTOP | MB_OK, Format(20), err);
  139.                 errorRant(hwndMDIFrame);
  140.                 return -1;
  141.             } 
  142.             wrl = WriteComm(modemHandle, &mb, buflen + 4 + 2 * sizeof(unsigned short));
  143.             err = GetCommError(modemHandle, &cs);
  144.             if (err != 0) { 
  145.                 MsgBox(hwndMDIFrame, MB_ICONSTOP | MB_OK, Format(21), err);
  146.                 errorRant(hwndMDIFrame);
  147.                 return -1;
  148.             } 
  149.             if (wrl > 0) {
  150.                 wrl = WriteComm(modemHandle, &bcrc, sizeof(short));
  151.             }
  152.             err = GetCommError(modemHandle, &cs);
  153.             if (err != 0) { 
  154.                 MsgBox(hwndMDIFrame, MB_ICONSTOP | MB_OK, Format(22), err);
  155.                 errorRant(hwndMDIFrame);
  156.                 return -1;
  157.             }
  158.             return buflen;
  159.         }
  160.     } else {
  161.         int stat;
  162.         
  163.         if ((!useSendNotSendto || waNetNoConnect) && (!waNetUseSend)) {
  164. //if (packetsSent == 200) { stat = -1; } else        
  165.             stat = sendto(d->sReply, buf, buflen, 0,
  166.                     (LPSOCKADDR) &(d->name), sizeof d->name);
  167.             if (stat < 0) {
  168.                 if (!waNetNoConnect) {
  169.                     useSendNotSendto = TRUE;
  170.                     if (hDlgPropeller != NULL) {
  171.                         SetDlgItemText(hDlgPropeller, IDC_PH_SENDTO, rstring(IDS_T_SEND));
  172.                     }
  173.                 }
  174.             }
  175.         }
  176.         /*    Careful!  Don't "optimise" this to "else if"; we have to be
  177.             able to switch-hit when the first sendto() fails above. */
  178.         if (useSendNotSendto) {
  179.             stat = send(d->sReply, buf, buflen, 0);
  180.         }
  181.         if (stat >= 0) {
  182.             d->outputSocketBusy = TRUE;
  183.             propeller(IDC_PH_PACKETS_SENT, ++packetsSent);
  184.         } else {
  185.             propeller(IDC_PH_OUTPUT_LOST, ++outputPacketsLost);
  186.         }        
  187.         return stat;
  188.     }
  189. }
  190.  
  191. //    SOCKETERRORBOX  --  Show message box for socket error
  192.  
  193. static void socketerrorbox(HWND hwnd, LPCLIENT_DATA d)
  194. {
  195.     if (d->modemConnection) {
  196.         MessageBox(hwnd, rstring(IDS_T_MODEM_WRITE_ERR), NULL,
  197.             MB_ICONEXCLAMATION | MB_OK);
  198.     } else {
  199.         MessageBox(hwnd, SockerrToString(WSAGetLastError()), rstring(IDS_T_SOCKET_WRITE_ERR),
  200.             MB_ICONEXCLAMATION | MB_OK);
  201.     }
  202. } 
  203.  
  204. /*  SENDPKT  --  Send a message to the destination.  */
  205.  
  206. static int sendpkt(HWND hwnd, LPCLIENT_DATA d, struct soundbuf *asb)
  207. {
  208.     LONG lts = asb->buffer.buffer_len;
  209.  
  210.     if (d->deskey[0] || d->ideakey[0] || d->opgpkey[0] || d->otpFileName[0]) {
  211.         int i;
  212.         LONG slen;
  213.  
  214.         _fmemcpy(&ebuf, asb, (int) ((sizeof(struct soundbuf) - BUFL) + lts));
  215.         slen = lts;
  216.  
  217.         /* DES encryption. */
  218.  
  219.         if (d->deskey[0]) {
  220.             char twibble[8];
  221.             
  222.             _fmemcpy(twibble, d->deskey + 1, 8);
  223.             setkey(twibble);
  224.  
  225.             /* If we're DES encrypting we must round the size of
  226.                the data to be sent to be a multiple of 8 so that
  227.                the entire DES frame is sent. */
  228.  
  229.             slen = (slen + 7) & (~7);
  230.             for (i = 0; i < slen; i += 8) {
  231.  
  232.                 /* Apply cipher block chaining within the packet. */
  233.  
  234.                 if (i > 0) {
  235.                     int j;
  236.  
  237.                     for (j = 0; j < 8; j++) {
  238.                         ebuf.buffer.buffer_val[(i + j)] ^=
  239.                             ebuf.buffer.buffer_val[(i + j) - 8];
  240.                     }
  241.                 }
  242.                 endes(ebuf.buffer.buffer_val + i);
  243.             }
  244.             ebuf.compression |= fEncDES;
  245.         }
  246.  
  247.         /* IDEA encryption. */
  248.  
  249.         if (d->ideakey[0]) {
  250.             unsigned short iv[4];
  251.             char twibble[16];
  252.             
  253.             _fmemcpy(twibble, d->ideakey + 1, 16);
  254.             memset(iv, 0, sizeof(iv));
  255.             initcfb_idea(iv, twibble, FALSE);
  256.  
  257.             /* If we're IDEA encrypting we must round the size of
  258.                the data to be sent to be a multiple of 8 so that
  259.                the entire IDEA frame is sent. */
  260.  
  261.             slen = (slen + 7) & (~7); 
  262.             ideacfb(ebuf.buffer.buffer_val, (int) slen);
  263.             close_idea();
  264.             ebuf.compression |= fEncIDEA;
  265.         }
  266.  
  267.         /* PGP session key encryption. */
  268.  
  269.         if (d->opgpkey[0]) {
  270.             unsigned short iv[4];
  271.             char twibble[16];
  272.             
  273.             _fmemcpy(twibble, d->opgpkey + 1, 16);
  274.             memset(iv, 0, sizeof(iv));
  275.             initcfb_idea(iv, twibble, FALSE);
  276.  
  277.             /* If we're IDEA encrypting we must round the size of
  278.                the data to be sent to be a multiple of 8 so that
  279.                the entire IDEA frame is sent. */
  280.  
  281.             slen = (slen + 7) & (~7); 
  282.             ideacfb(ebuf.buffer.buffer_val, (int) slen);
  283.             close_idea();
  284.             ebuf.compression |= fEncPGP;
  285.         }
  286.  
  287.         /* One-time pad encryption. */
  288.  
  289.         if (d->otpFileName[0]) {
  290.             for (i = 0; i < slen; i++) {
  291.                 ebuf.buffer.buffer_val[i] ^= d->otp[i];
  292.             }
  293.             ebuf.compression |= fEncOTP;
  294.         }
  295.         revlong(&ebuf.compression);
  296.         revlong(&ebuf.buffer.buffer_len);
  297.  
  298.         if (writeOutput(d, (LPSTR) &ebuf,
  299.                 (int) ((sizeof(struct soundbuf) - BUFL) + slen)) < 0) {
  300.             d->state = d->wantsInput ? SendingLiveAudio : Idle;
  301.             if (d->hFile != HFILE_ERROR) {
  302.                 KillTimer(hwnd, 2);
  303.                 _lclose(d->hFile);
  304.                 d->hFile = HFILE_ERROR;
  305.             }
  306.             socketerrorbox(hwnd, d);
  307.             return FALSE;
  308.         }
  309.     } else {
  310.         int stat;
  311.         
  312.         revlong(&asb->compression);
  313.         revlong(&asb->buffer.buffer_len);
  314.         stat = writeOutput(d, (LPSTR) asb,
  315.             (int) ((sizeof(struct soundbuf) - BUFL) + lts));
  316.         revlong(&asb->compression);
  317.         revlong(&asb->buffer.buffer_len);
  318.         if (stat < 0) {
  319.             d->state = d->wantsInput ? SendingLiveAudio : Idle;
  320.             d->wantsInput = FALSE;
  321.             if (d->hFile != HFILE_ERROR) {
  322.                 KillTimer(hwnd, 2);
  323.                 _lclose(d->hFile);
  324.                 d->hFile = HFILE_ERROR;
  325.             }
  326.             socketerrorbox(hwnd, d);
  327.             return FALSE;
  328.         }
  329.     }
  330.     return TRUE;
  331. }
  332.  
  333. /*  SHIPSOUNDBUFFER  --  Output sound buffer to connection.  */
  334.  
  335. void shipSoundBuffer(HWND hwnd, LPCLIENT_DATA pClientData)
  336. {
  337.     sb.compression = pClientData->ring ? (fSetDest | fDestSpkr) : 0;
  338.     pClientData->ring = FALSE;
  339.     sb.compression |= pClientData->debugging ? fDebug : 0;
  340.     sb.compression |= pClientData->loopback ? fLoopBack : 0;
  341.     sb.compression |= compression ? fComp2X : 0;
  342.     sb.compression |= gsmcompress ? fCompGSM : 0;
  343.     sb.compression |= adpcmcompress ? fCompADPCM : 0;
  344.     sb.compression |= lpccompress ? fCompLPC : 0;
  345.     sb.compression |= (faceFile != HFILE_ERROR) ? fFaceOffer : 0;
  346.     
  347.     sendpkt(hwnd, pClientData, &sb);
  348. }
  349.  
  350. /*  CREATESOUNDBUFFER  --  Create a standard format sound buffer
  351.                            with selected compression modes from a
  352.                            set of raw samples received from the audio
  353.                            input port.  */
  354.                         
  355. void createSoundBuffer(LPSTR buffer, WORD buflen, DWORD channels,
  356.                        DWORD rate, DWORD bytesec, WORD align)
  357. {
  358.     int knownFormat = FALSE;
  359.     
  360.     if (rate == 8000) {
  361.         if (align == 2) {
  362.             LONG i;
  363.             int j;
  364.             
  365.             for (i = j = 0; i < (LONG) buflen / align; i++) {
  366.                 sb.buffer.buffer_val[j++] = audio_s2u((((WORD FAR *) buffer)[i]));
  367.             } 
  368.         } else {    // align == 1
  369.             LONG i;
  370.             int j;
  371.             
  372.             for (i = j = 0; i < (LONG) buflen; i++) {
  373.                 sb.buffer.buffer_val[j++] = audio_c2u((((BYTE FAR *) buffer)[i]));
  374.             } 
  375.         }
  376.         sb.buffer.buffer_len = buflen / align;
  377.         knownFormat = TRUE;
  378.     } else if (rate == 11025 && align == 2) {
  379.         LONG i;
  380.         int j, k;
  381.         
  382.         for (i = j = k = 0; i < (LONG) (buflen / align); i++) {
  383.             if ((k & 3) != 2  && ((i % 580) != 579)) {
  384.                 sb.buffer.buffer_val[j++] = audio_s2u((((WORD FAR *) buffer)[i]));
  385.             }
  386.             k = (k + 1) % 11;
  387.         } 
  388.         sb.buffer.buffer_len = j;
  389.         knownFormat = TRUE;
  390.     } else if (rate == 11025 && align == 1) {
  391.         LONG i;
  392.         int j, k;
  393.         
  394.         for (i = j = k = 0; i < (LONG) (buflen / align); i++) {
  395.             if ((k & 3) != 2  && ((i % 580) != 579)) {
  396.                 sb.buffer.buffer_val[j++] = audio_c2u((((BYTE FAR *) buffer)[i]));
  397.             }
  398.             k = (k + 1) % 11;
  399.         } 
  400.         sb.buffer.buffer_len = j;
  401.         knownFormat = TRUE;
  402.     }
  403.     
  404.     if (knownFormat) {
  405.         if (compression) {
  406.             compress2X(&sb);
  407.         }
  408.     
  409.         if (gsmcompress) {
  410.             gsmcomp(&sb);
  411.         }
  412.  
  413.         if (adpcmcompress) {
  414.             adpcmcomp(&sb);
  415.         }
  416.  
  417.         if (lpccompress) {
  418.             lpccomp(&sb);
  419.         }
  420.     }
  421. }                                            
  422.  
  423. /*  CREATENEWCONNECTION  --  Create a new connection MDI window.  */
  424.  
  425. HWND createNewConnection(LPCLIENT_DATA pClientData)
  426. {
  427.     MDICREATESTRUCT mcs;
  428.     HWND hwnd;
  429.     SOCKERR serr = 0;
  430.  
  431. #ifdef TRACE_FACE
  432.         OutputDebugString("createNewConnection()\r\n");
  433. #endif
  434.     mcs.szClass = pszClientClass;
  435.     mcs.szTitle = pClientData->szHost,
  436.     mcs.hOwner = hInst;
  437.     mcs.x = CW_USEDEFAULT;
  438.     mcs.y = CW_USEDEFAULT;
  439.     mcs.cx = tmAveCharWidth * 30;
  440.     mcs.cy = tmHeight * 5;
  441.     mcs.style = 0;
  442.  
  443.     hwnd = FORWARD_WM_MDICREATE(hwndMDIClient, (LPMDICREATESTRUCT) &mcs, SendMessage);
  444.  
  445.     if (hwnd == NULL) {
  446.         return NULL;
  447.     }
  448.     
  449.     pClientData->state = Idle;
  450.     SetWindowLong(hwnd, GWL_CLIENT, (LONG) pClientData);
  451.     if (!pClientData->modemConnection) {
  452.         serr = CreateSocket(&(pClientData->sReply), SOCK_DGRAM,
  453.                              htonl(INADDR_ANY), 0);
  454.     
  455.         if (serr == 0) {
  456.             pClientData->name.sin_family = PF_INET;
  457.             pClientData->name.sin_addr = pClientData->inetSock.sin_addr;
  458.             pClientData->name.sin_port = htons(NETFONE_COMMAND_PORT);
  459.             
  460.             if (!waNetNoConnect) {
  461.                 if (connect(pClientData->sReply, (LPSOCKADDR) &(pClientData->name),
  462.                      sizeof(pClientData->name)) != 0) {
  463.                     serr = WSAGetLastError();
  464.                 }
  465.             }
  466. #ifdef ASYNC_OUTPUT            
  467.             if (serr == 0) {
  468.                 serr = WSAAsyncSelect(pClientData->sReply, hwnd, WM_SOCKET_SELECT,
  469.                                 FD_WRITE);
  470.              }
  471. #endif             
  472.            }
  473.         if (serr != 0) {
  474.            MsgBox(hwnd, MB_ICONSTOP | MB_OK, Format(23),
  475.                     (LPSTR) pClientData->szHost, serr, SockerrToString(serr));
  476.             return NULL;
  477.         }
  478.     }
  479.  
  480.     pClientData->gsmh = gsm_create();
  481.     
  482.     /* Since the sending buffer is static, there's no reason
  483.        to get the host name for every packet (like, it doesn't
  484.        change, right?).  So just get it when we initialise a new
  485.        connection.  The nonsense with "gh" is because some WINSOCK
  486.        implementations fail if the host buffer is too small, as
  487.        opposed to truncating the name as Unix does. */
  488.     
  489.     {
  490.         char gh[MAX_HOST];
  491.         
  492.         gethostname(gh, sizeof gh);
  493.         if (strlen(gh) > ((sizeof sb.sendinghost) - 1)) {
  494.             gh[(sizeof sb.sendinghost) - 1] = 0;
  495.         }
  496.         strcpy(sb.sendinghost, gh);
  497.     }
  498.     
  499.     if (pClientData->modemConnection) {
  500.         SetWindowText(hwnd, rstring(IDS_T_MODEM_CONNECTION));
  501.         modemSessions++;
  502.     } else if (pClientData->szHost[0] == '(') {
  503.         /* This is a temporary connection initiated from the remote site.
  504.            Schedule a lookup to obtain the full domain name of the host,
  505.            not just the hostname included in the sound packet. */
  506.         pClientData->getNameTask = WSAAsyncGetHostByAddr(hwnd, WM_SOCKET_ASYNC,
  507.                                         (CHAR FAR *) &pClientData->inetSock.sin_addr,
  508.                                         sizeof(pClientData->inetSock.sin_addr),
  509.                                         PF_INET, pClientData->hostBuffer,
  510.                                         sizeof(pClientData->hostBuffer));
  511.         if (pClientData->getNameTask == NULL) {
  512.             int serr = WSAGetLastError();
  513.             MsgBox(hwnd, MB_ICONSTOP | MB_OK, Format(24),
  514.                     (LPSTR) pClientData->szHost, serr, SockerrToString(serr));
  515.         }                                 
  516.     }
  517.  
  518.     DragAcceptFiles(hwnd, TRUE);
  519.     ShowWindow(hwnd, SW_SHOW);
  520.     openConnections++;
  521.     propUpdateAudio();
  522.  
  523.     return hwnd;
  524. }
  525.  
  526. //    CONNFETCHFACE  --  Begin retrieval of a face image.
  527.  
  528. void connFetchFace(HWND hwndClient, LPCLIENT_DATA pClientData)
  529. {
  530. //    pClientData->face_stat = FSabandoned;
  531. //    if (pClientData->face_stat != -1) {
  532. #ifdef TRACE_FACE
  533.         OutputDebugString("connFetchFace()\r\n");
  534. #endif
  535.         pClientData->face_address = 0L;
  536.         pClientData->face_timeout = 0;
  537.         pClientData->face_retry = 0;
  538.         pClientData->face_stat = FSreply;       // Activate request from timeout
  539.         SetTimer(hwndClient, 5, (UINT) FaceFetchInterval, NULL);
  540. //    }
  541. }
  542.  
  543. //    STARTSOUNDFILE  --  Begin playing a sound file.
  544.  
  545. VOID startSoundFile(HWND hwnd, LPSTR pszFile)
  546. {
  547.     LPCLIENT_DATA pClientData;
  548.     HFILE hFile = HFILE_ERROR;
  549.     char magic[4];
  550.  
  551.     pClientData = CLIENTPTR(hwnd);
  552.     
  553.     pClientData->quitSoundFile = FALSE;
  554.     pClientData->hFile = HFILE_ERROR;
  555.     if (pClientData->timeout > 0) {
  556.         pClientData->timeout = 0;
  557.     }
  558.     pClientData->cbSent = 0L;
  559.  
  560.     //  Try to open it
  561.  
  562.     hFile = _lopen(pszFile, OF_READ | OF_SHARE_DENY_WRITE);
  563.  
  564.     if (hFile == HFILE_ERROR) {
  565.         //  Error opening file
  566.  
  567.         MsgBox(hwnd, MB_ICONSTOP | MB_OK, Format(25),
  568.                 pszFile, (LPSTR) pClientData->szHost);
  569.         goto FatalError;
  570.     }
  571.     _lread(hFile, magic, sizeof(long));
  572.     
  573.     /* See if it's a chunky, wavy RIFF.  If so, delegate
  574.        handling of the file to the multimedia I/O package. */
  575.        
  576.     if (memcmp(magic, "RIFF", 4) == 0) {
  577.         _lclose(hFile);
  578.         if (!readWaveInit(hwnd, pClientData, pszFile)) {
  579.             return;
  580.         }
  581.     } else {
  582.     
  583.         /* If the file has a Sun .au file header, skip it.
  584.            Note that we still blithely assume the file is
  585.            8-bit ISDN u-law encoded at 8000 samples per
  586.            second. */
  587.     
  588.         if (memcmp(magic, ".snd", 4) == 0) {
  589.             long startpos;
  590.     
  591.             _lread(hFile, &startpos, sizeof(long));
  592.             revlong(&startpos);
  593.             _llseek(hFile, startpos, 0);
  594.         } else {
  595.             _llseek(hFile, 0L, 0);
  596.         }
  597.         pClientData->hFile = hFile;
  598.     }
  599.     
  600.     pClientData->state = Transferring;
  601.     if (pClientData->timeout > 0) {
  602.         pClientData->timeout = 0;
  603.     }
  604.  
  605. #ifdef SHOW_STATE
  606.     InvalidateRect(hwnd, NULL, TRUE);
  607.     UpdateWindow(hwnd);
  608. #endif    
  609.     DragAcceptFiles(hwnd, FALSE);
  610.     if (SetTimer(hwnd, 2, 200, NULL) == 0) {
  611.         MsgBox(NULL, MB_ICONSTOP | MB_OK, Format(26));
  612.     }
  613.     return;
  614.  
  615. FatalError:
  616.     if (hFile != HFILE_ERROR) {
  617.         _lclose(hFile);
  618.     }
  619. }
  620.  
  621. /*  FILEDROPPED  --  Handle file dropped in connection window.  */
  622.  
  623. static VOID fileDropped(HWND hwnd, HDROP hdrop)
  624. {
  625.     LPCLIENT_DATA pClientData;
  626.     
  627.     pClientData = CLIENTPTR(hwnd);
  628.  
  629.     //  Retrieve the dropped file
  630.  
  631.     DragQueryFile(hdrop, 0, pClientData->szFile, sizeof(pClientData->szFile));
  632.     DragFinish(hdrop);
  633.     
  634.     //    Start output
  635.     
  636.     startSoundFile(hwnd, pClientData->szFile); 
  637. }
  638.  
  639. /*  STATETOSTRING  --  Convert state value to string.  */
  640.  
  641. static LPSTR stateToString(CLIENT_STATE state)
  642. {
  643.     LPSTR pszResult;
  644.  
  645.     switch (state) {
  646.         case Embryonic:
  647.             pszResult = rstring(IDS_T_INITIALISING);
  648.             break;
  649.     
  650.         case Idle:
  651.             pszResult = rstring(IDS_T_IDLE);
  652.             break;
  653.     
  654.         case SendingLiveAudio:
  655.             pszResult = rstring(IDS_T_SENDING_LIVE);
  656.             break;
  657.     
  658.         case Transferring:
  659.             pszResult = rstring(IDS_T_SENDING_FILE);
  660.             break;
  661.     
  662.         case PlayingReceivedAudio:
  663.             pszResult = rstring(IDS_T_PLAYING_AUDIO);
  664.             break;
  665.     
  666.         default:
  667.             pszResult = rstring(IDS_T_UNKNOWN);
  668.             break;
  669.     }
  670.     return pszResult;
  671. }
  672.  
  673. /*    CHANGEAUDIOSTATE  --  Change transmitting / receiving state.  */
  674.  
  675. static void changeAudioState(HWND hwnd, LPCLIENT_DATA pClientData)
  676. {
  677.     if (pClientData->face_shown) {
  678.         LPSTR hname = pClientData->modemConnection ?
  679.                 rstring(IDS_T_MODEM_CONNECTION) : pClientData->szHost;
  680.         if (pClientData->wantsInput) {
  681.             char s[MAX_HOST + 20];
  682.             
  683.             strcpy(s, "==> ");
  684.             _fstrcat(s, hname);
  685.             SetWindowText(hwnd, s); 
  686.         } else {
  687.             SetWindowText(hwnd, hname);
  688.         } 
  689.     } else {
  690.         InvalidateRect(hwnd, NULL, TRUE);
  691.         UpdateWindow(hwnd);
  692.     }
  693. }
  694.  
  695. /*  DESTROYCONNECTION  --  Destroy connection, cleaning up debris
  696.                            and releasing resources.  */
  697.  
  698. static VOID destroyConnection(HWND hwnd, LPCLIENT_DATA pClientData)
  699. {
  700.     if (pClientData->sReply != INVALID_SOCKET) {
  701.         ResetSocket(pClientData->sReply);
  702.         pClientData->sReply = INVALID_SOCKET;
  703.     }
  704.  
  705.     if (pClientData->hFile != HFILE_ERROR) {
  706.         _lclose(pClientData->hFile);
  707.         pClientData->hFile = HFILE_ERROR;
  708.     }
  709.  
  710.     pClientData->state = Idle;
  711.  
  712.     if (hwnd != NULL) {
  713. #ifdef SHOW_STATE
  714.         InvalidateRect(hwnd, NULL, TRUE);
  715.         UpdateWindow(hwnd);
  716. #endif        
  717.         DragAcceptFiles(hwnd, TRUE);
  718.     }
  719. }
  720.  
  721. /*  CONNECT_WNDPROC  --  Connection main window procedure.  */
  722.  
  723. LRESULT CALLBACK connectWndProc(HWND hwnd, UINT nMessage, WPARAM wParam, LPARAM lParam)
  724. {
  725.     LPCLIENT_DATA pClientData;
  726.  
  727.     pClientData = CLIENTPTR(hwnd);
  728.     
  729.     switch (nMessage) {
  730.     
  731. //        case WM_MDIACTIVATE:
  732. //            if (wParam) {
  733. //                InvalidateRect(hwnd, NULL, FALSE);
  734. //                UpdateWindow(hwnd);
  735. //            }
  736. //            break;
  737.     
  738.         case WM_CHAR:
  739.             if (wParam == ' ') {
  740.                 if (pClientData != NULL) {
  741.                     if (!pClientData->wantsInput) {
  742.                         goto spacebarOn;
  743.                     } else {
  744.                         goto spacebarOff;
  745.                     }
  746.                 }    
  747.             }
  748.             return 0;
  749.         
  750.         case WM_CLOSE:
  751.             if (pClientData != NULL) {
  752.                 destroyConnection(NULL, pClientData);
  753.             }
  754.             FORWARD_WM_CLOSE(hwnd, DefMDIChildProc);
  755.             return 0;
  756.             
  757.         case WM_CREATE:
  758. #ifdef TRACE_FACE
  759.             OutputDebugString("Connection WM_CREATE()\r\n");
  760. #endif
  761.             SetFocus(hwnd);
  762.             break;
  763.         
  764.         case WM_DESTROY:
  765.             if (pClientData != NULL) {
  766.                 if (pClientData->wantsInput && --listeners <= 0) {
  767.                     terminateWaveInput();
  768.                     listeners = 0;
  769.                 }
  770.                 gsm_destroy(pClientData->gsmh);
  771.                 if (pClientData->hFile != HFILE_ERROR ||
  772.                     pClientData->mmioHandle != NULL) {
  773.                     KillTimer(hwnd, 2);
  774.                     if (pClientData->hFile != HFILE_ERROR) {
  775.                         _lclose(pClientData->hFile);
  776.                     }
  777.                     readWaveTerm(pClientData);
  778.                 }
  779.                 
  780.                 if (pClientData->pgpFileName[0] != 0) {
  781.                     KillTimer(hwnd, 3);                // Kill timer for incomplete PGP poll
  782.                     // T'would be nice to clean up the temp files here as well.
  783.                 }
  784.                 
  785.                 if (pClientData->opgpFileName[0] != 0) {
  786.                     KillTimer(hwnd, 4);                // Kill timer for incomplete PGP poll
  787.                     // T'would be nice to clean up the temp files here as well.
  788.                 }
  789.                 
  790.                 if (pClientData->face_stat == FSrequest ||
  791.                     pClientData->face_stat == FSreply) {
  792.                     KillTimer(hwnd, 5);                // Kill timer for incomplete face image
  793.                 }
  794.                 if (pClientData->face_bmp != NULL) {
  795.                     GlobalFreePtr(pClientData->face_bmp);    // Release face bitmap
  796.                 }
  797.  
  798.                 if (pClientData->modemConnection) {
  799.                     modemSessions--;
  800.                 }
  801.                 
  802.                 if (pClientData->getNameTask != NULL) {
  803.                     WSACancelAsyncRequest(pClientData->getNameTask);
  804.                     pClientData->getNameTask = NULL;    
  805.                 }
  806.                 
  807.                 GlobalFreePtr(pClientData);
  808.                 SetWindowLong(hwnd, GWL_CLIENT, 0L);
  809.             } 
  810.             openConnections--;
  811.             propUpdateAudio();
  812.             return 0;
  813.             
  814.         case WM_DROPFILES:
  815.             if (pClientData != NULL && !broadcasting) {
  816.                 pClientData->timeout = -1;    // Send file immortalises connection
  817.                 fileDropped(hwnd, (HDROP) wParam);
  818.             }
  819.             break;
  820.  
  821. #ifdef GATES_OF_HELL
  822.  
  823.         /* Well, golly, I though it would be kinda nice to keep
  824.            the user from inflating the connection window larger than
  825.            the face image in it--doing so only wastes screen
  826.            real estate, after all.  Little did I know that by trying
  827.            to do so (at least with an MDI window), I stuck my toe
  828.            back into the tree chipper and caused all kinds of
  829.            things to let go--window size changing when iconised
  830.            and reactivated, the "disappearing minimise button
  831.            syndrome", etc. etc.  The Developer CD serves up the
  832.            usual crop of incoherent blithering.  I give up--go
  833.            ahead and make the bloody window as big as Siberia
  834.            if you like. */
  835.             
  836.         case WM_GETMINMAXINFO:
  837.             if (pClientData != NULL && pClientData->face_shown) {
  838.                 MINMAXINFO FAR *mm = (MINMAXINFO FAR *) lParam;
  839.                 BITMAPINFOHEADER FAR *bmi;
  840.                 RECT cr, wr;
  841.                         
  842.                 GetWindowRect(hwnd, &wr);
  843.                 GetClientRect(hwnd, &cr);
  844.                             
  845.                 bmi = (BITMAPINFOHEADER FAR *) (pClientData->face_bmp + sizeof(BITMAPFILEHEADER));
  846.                 
  847.                 //    Don't allow resize of window larger than face
  848.  
  849.                 mm->ptMaxSize.x = mm->ptMaxTrackSize.x = ((int) bmi->biWidth) + ((wr.right - wr.left) - cr.right); 
  850.                 mm->ptMaxSize.x = mm->ptMaxTrackSize.y = ((int) bmi->biHeight) + ((wr.bottom - wr.top) - cr.bottom); 
  851.             } 
  852.             break;
  853. #endif            
  854.             
  855.         case WM_LBUTTONDBLCLK:
  856.         case WM_LBUTTONDOWN:
  857. spacebarOn: if (pClientData != NULL && !pClientData->wantsInput && !broadcasting) {
  858.                 if (listeners == 0) {
  859.                     if (!startWaveInput(hwnd)) {
  860.                         //    Couldn't turn on wave audio input
  861.                         break;
  862.                     }
  863.                 }
  864.                 pClientData->wantsInput = (nMessage == WM_LBUTTONDBLCLK) ? 2 : TRUE;
  865.                 listeners++;
  866.                 pClientData->timeout = -1;    // Send audio immortalises connection
  867.                 pClientData->state = SendingLiveAudio;
  868.                 SetCursor(earCursor);
  869.                 changeAudioState(hwnd, pClientData);
  870.             }
  871.             break;
  872.             
  873.         case WM_LBUTTONUP:
  874. spacebarOff:if (pClientData != NULL && !broadcasting) {
  875.                 if (pClientData->wantsInput == TRUE) {
  876.                     pClientData->wantsInput = FALSE;
  877.                     pClientData->state = pClientData->hFile != HFILE_ERROR ?
  878.                         Transferring : Idle;
  879.                     SetCursor(phoneCursor);
  880.                     changeAudioState(hwnd, pClientData);
  881.                     if (--listeners <= 0) {
  882.                         terminateWaveInput();
  883.                         listeners = 0;
  884.                     }
  885.                 /* If this the button-up following a double click, don't
  886.                    turn off listening.  This allows a double click to latch
  887.                    input mode for a window. */
  888.                 } else if (pClientData->wantsInput == 2) {
  889.                     pClientData->wantsInput = TRUE;
  890.                     SetCursor(earCursor);
  891.                     UpdateWindow(hwnd);
  892.                 }
  893.             } 
  894.             break;
  895.             
  896.         case WM_MOUSEMOVE:
  897.             if (pClientData != NULL) {
  898.                 SetCursor((pClientData->wantsInput || broadcasting) ? earCursor :
  899.                             phoneCursor);
  900.             }
  901.             break;
  902.         
  903.         case WM_PAINT:
  904.             {
  905. #define DCOL    11            
  906.                 PAINTSTRUCT psPaint;
  907.                 HDC hdc;
  908.                 HBITMAP ibmap = NULL;
  909.                 int active = hwnd == ((HWND) LOWORD(SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L)));
  910.  
  911.                 hdc = BeginPaint(hwnd, &psPaint);
  912.                 if (pClientData != NULL) {
  913.                     if (pClientData->face_stat == FScomplete &&
  914.                         pClientData->face_bmp != NULL) {
  915.                         int bx, by;
  916.                         RECT cr, wr;
  917.                         BITMAPFILEHEADER FAR *bfh;
  918.                         BITMAPINFOHEADER FAR *bmi;
  919.                         char _huge *bits;
  920.                         HPALETTE bpal = NULL, opal;
  921.                         int i;
  922.                         LPLOGPALETTE lp;
  923.                         BITMAPINFO FAR *bh;
  924.                         unsigned short FAR *palidx;
  925.                         LPSTR lpalette;
  926.                         unsigned short FAR *savepal;
  927. #ifdef TRACE_FACE
  928. {    char s[256];
  929.                         
  930.     wsprintf(s, "Paint %04X: %s\r\n", hwnd, pClientData->szHost);
  931.     OutputDebugString(s);
  932. }
  933. #endif                        
  934.                         
  935.                         pClientData->face_shown = FALSE;
  936.                         savepal = (unsigned short FAR *) GlobalAllocPtr(GPTR,
  937.                                     sizeof(LOGPALETTE) +
  938.                                     sizeof(PALETTEENTRY) * 256 +
  939.                                     sizeof(short) * 256);
  940.                         if (savepal == NULL) {
  941.                             goto face_failed;
  942.                         }
  943.                         lpalette = ((LPSTR) savepal) + 256 * sizeof(short); 
  944.                         GetWindowRect(hwnd, &wr);
  945.                         GetClientRect(hwnd, &cr);
  946.                         
  947.                         bfh = (BITMAPFILEHEADER FAR *) pClientData->face_bmp;
  948.                         bmi = (BITMAPINFOHEADER FAR *) (pClientData->face_bmp + sizeof(BITMAPFILEHEADER));
  949.                         bh = (BITMAPINFO FAR *) bmi; 
  950.                         bx = (int) bmi->biWidth;
  951.                         by = (int) bmi->biHeight;
  952.                         
  953.                         if (bmi->biClrUsed == 0) {
  954.                             bmi->biClrUsed = 1L << bmi->biBitCount;
  955.                         }
  956.  
  957.                         bits = (char FAR *) (pClientData->face_bmp + bfh->bfOffBits);
  958.  
  959.                         lp = (LOGPALETTE FAR *) lpalette;
  960.                         palidx = (unsigned short FAR *) bh->bmiColors;
  961.                         _fmemcpy(savepal, palidx, 256 * sizeof(short));
  962.                         lp->palVersion = 0x0300;
  963.                         lp->palNumEntries = (WORD) bmi->biClrUsed;
  964.                         for (i = 0; i < ((int) bmi->biClrUsed); i++) {
  965.                             lp->palPalEntry[i].peRed = bh->bmiColors[i].rgbRed;
  966.                             lp->palPalEntry[i].peGreen = bh->bmiColors[i].rgbGreen;
  967.                             lp->palPalEntry[i].peBlue = bh->bmiColors[i].rgbBlue;
  968.                             lp->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
  969.                             if (active) {
  970. //                                palidx[i] = (unsigned short) i;
  971.                             }
  972.                         }
  973.                         bpal = CreatePalette(lp);
  974.                         if (active && bpal != NULL) {
  975.                             opal = SelectPalette(hdc, bpal, FALSE);
  976.                             RealizePalette(hdc);
  977.                         }
  978.  
  979.                         ibmap = CreateDIBitmap(hdc, bmi, CBM_INIT,
  980.                                     bits, (BITMAPINFO FAR *) bmi, DIB_RGB_COLORS);
  981.                         _fmemcpy(palidx, savepal, 256 * sizeof(short));
  982.                         if (ibmap != NULL) {
  983.                             HDC hMemDC;
  984.                             HBITMAP obmap;
  985.                             HPALETTE mopal;
  986.         
  987.                             hMemDC = CreateCompatibleDC(hdc);
  988.                             if (bpal != NULL) {
  989.                                 mopal = SelectPalette(hMemDC, bpal, FALSE);
  990.                             }
  991.                             obmap = SelectObject(hMemDC, ibmap);
  992.                             if (bx <= cr.right && by <= cr.bottom) {
  993.                                 BitBlt(hdc, (cr.right - bx) / 2, (cr.bottom - by) / 2,
  994.                                     bx, by, hMemDC, 0, 0, SRCCOPY);
  995.                             } else {
  996.                                 int nx, ny;
  997.                                 double xshrink = ((double) bx) / cr.right,
  998.                                        yshrink = ((double) by) / cr.bottom;
  999.         
  1000. #ifdef TRACE_FACE
  1001.                                 OutputDebugString("Yick!!!  Had to stretch face bitmap.\r\n");
  1002. #endif
  1003.                                 if (xshrink > yshrink) {
  1004.                                     nx = cr.right;
  1005.                                     ny = (int) (by / xshrink);
  1006.                                 } else {
  1007.                                     ny = cr.bottom;
  1008.                                     nx = (int) (bx / yshrink);
  1009.                                 }
  1010.                                 SetStretchBltMode(hdc, STRETCH_DELETESCANS);
  1011.                                 StretchBlt(hdc, (cr.right - nx) / 2, (cr.bottom - ny) / 2, nx, ny,
  1012.                                     hMemDC, 0, 0, bx, by, SRCCOPY);
  1013.                             }
  1014.                             SelectObject(hMemDC, obmap);
  1015.                             DeleteObject(ibmap);
  1016.                             if (bpal != NULL) {
  1017.                                 if (active) {
  1018.                                     SelectPalette(hdc, opal, FALSE);
  1019.                                 }
  1020.                                 SelectPalette(hMemDC, mopal, FALSE);
  1021.                                 DeleteObject(bpal);
  1022.                             }
  1023.                             DeleteDC(hMemDC);
  1024.                             pClientData->face_shown = TRUE;
  1025.                         }
  1026.                         GlobalFreePtr(savepal);                        
  1027.                     }
  1028. face_failed:                    
  1029.                     if (!pClientData->face_shown) {
  1030.                         WinPrintf(hdc, 0, 1, pClientData->modemConnection ?
  1031.                             rstring(IDS_T_DIAL_STRING) : rstring(IDS_T_HOST));
  1032.                         WinPrintf(hdc, 0, DCOL, pClientData->szHost);
  1033.                         
  1034.                         if (pClientData->modemConnection) {
  1035.                             WinPrintf(hdc, 1, 1, rstring(IDS_T_MODEM_CONNECTION_L));
  1036.                         } else {
  1037.                             WinPrintf(hdc, 1, 1, rstring(IDS_T_ADDRESS));
  1038.                             WinPrintf(hdc, 1, DCOL, Format(48), inet_ntoa(pClientData->inetSock.sin_addr));
  1039.                         }
  1040.                         
  1041.                         WinPrintf(hdc, 2, 1, pClientData->wantsInput ? rstring(IDS_T_TRANSMITTING) :
  1042.                             rstring(IDS_T_BLANKTRANSMIT));
  1043.     
  1044. #ifdef SHOW_STATE
  1045.                         /* It's nice to show the state, but costly to update on
  1046.                            every packet. */
  1047.                                        
  1048.                         WinPrintf(hdc, 3, 1, "State:");
  1049.                         WinPrintf(hdc, 3, DCOL, "%s", stateToString(pClientData->state));
  1050.                 
  1051.                         switch (pClientData->state) {
  1052.                             case Idle:
  1053.                                 WinPrintf(hdc, 4, 1, blankit);
  1054.                                 WinPrintf(hdc, 5, 1, blankit);
  1055.                                 break;
  1056.                                 
  1057.                             case Transferring:
  1058.                                 WinPrintf(hdc, 4, 1, "File: ");
  1059.                                 WinPrintf(hdc, 4, DCOL, "%s", pClientData->szFile);
  1060.                                 WinPrintf(hdc, 5, 1, "Bytes sent:");
  1061.                                 WinPrintf(hdc, 5, DCOL, "%lu", pClientData->cbSent);
  1062.                                 break;
  1063.                                 
  1064.                             case PlayingReceivedAudio:
  1065.                                 WinPrintf(hdc, 4, 1, "Bytes received:");
  1066.                                 WinPrintf(hdc, 4, DCOL, "%lu", pClientData->cbReceived);
  1067.                                 break;                            
  1068.                         }
  1069. #endif                    
  1070.                     }
  1071. #undef DCOL
  1072.                 }                
  1073.             
  1074.                 EndPaint(hwnd, &psPaint);            
  1075.             }
  1076.             break;
  1077.             
  1078. case WM_MDIACTIVATE:
  1079.             if (wParam == FALSE || IsIconic(hwnd)) {
  1080.                 break;
  1081.             }
  1082.             if (pClientData != NULL && pClientData->face_shown) {
  1083.                 HDC hdc;
  1084.                 BITMAPINFOHEADER FAR *bmi;
  1085.                 HPALETTE bpal = NULL, opal;
  1086.                 int i;
  1087.                 LPLOGPALETTE lp;
  1088.                 BITMAPINFO FAR *bh;
  1089.                 LPSTR lpalette;
  1090. #ifdef TRACE_FACE
  1091. {    char s[256];
  1092.                         
  1093.     wsprintf(s, "MDI activate %04X: %s\r\n", hwnd, pClientData->szHost);
  1094.     OutputDebugString(s);
  1095. }
  1096. #endif                        
  1097.                         
  1098.                 lpalette =  GlobalAllocPtr(GPTR, sizeof(LOGPALETTE) +
  1099.                             sizeof(PALETTEENTRY) * 256);
  1100.                 if (lpalette != NULL) {
  1101.                     bmi = (BITMAPINFOHEADER FAR *) (pClientData->face_bmp + sizeof(BITMAPFILEHEADER));
  1102.                     bh = (BITMAPINFO FAR *) bmi; 
  1103.                     lp = (LOGPALETTE FAR *) lpalette;
  1104.                     lp->palVersion = 0x0300;
  1105.                     lp->palNumEntries = (WORD) bmi->biClrUsed;
  1106.                     for (i = 0; i < ((int) bmi->biClrUsed); i++) {
  1107.                         lp->palPalEntry[i].peRed = bh->bmiColors[i].rgbRed;
  1108.                         lp->palPalEntry[i].peGreen = bh->bmiColors[i].rgbGreen;
  1109.                         lp->palPalEntry[i].peBlue = bh->bmiColors[i].rgbBlue;
  1110.                         lp->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
  1111.                     }
  1112.                     bpal = CreatePalette(lp);
  1113.                     if (bpal != NULL) {
  1114.                            hdc = GetDC(hwnd);
  1115.                         opal = SelectPalette(hdc, bpal, FALSE);
  1116.                         i = RealizePalette(hdc);
  1117.                         SelectPalette(hdc, opal, FALSE);
  1118.                         DeleteObject(bpal);                        
  1119.                         ReleaseDC(hwnd, hdc);
  1120.                         if (i > 0) {
  1121.                             HWND oldwin;
  1122.                             
  1123.                             InvalidateRect(hwnd, NULL, TRUE);
  1124.                             UpdateWindow(hwnd);
  1125.                             oldwin = (HWND) HIWORD(lParam);
  1126.                             if (oldwin != NULL) {
  1127.                                 InvalidateRect(oldwin, NULL, TRUE);
  1128.                                 UpdateWindow(oldwin);
  1129.                             }
  1130.                         }
  1131.                         return i;
  1132.                     }
  1133.                     GlobalFreePtr(lpalette);
  1134.                 }
  1135.             }
  1136.             break;
  1137.  
  1138. #ifdef ASYNC_OUTPUT            
  1139.         case WM_SOCKET_SELECT:
  1140.             if (pClientData != NULL) {
  1141.                 pClientData->outputSocketBusy = FALSE;
  1142.             }
  1143.             return 0;
  1144. #endif            
  1145.             
  1146.         case WM_SOCKET_ASYNC:
  1147.             if (pClientData != NULL) {
  1148.                    if (WSAGETASYNCERROR(lParam) == 0) {
  1149.                     LPHOSTENT host;
  1150.                 
  1151.                     pClientData->getNameTask = NULL;
  1152.                     host = (LPHOSTENT) pClientData->hostBuffer;
  1153.                     SetWindowText(hwnd, host->h_name);
  1154.                     _fstrcpy(pClientData->szHost, host->h_name);
  1155.                     changeAudioState(hwnd, pClientData);
  1156.                 } else {
  1157.                    MsgBox(hwnd, MB_ICONSTOP | MB_OK, Format(27),
  1158.                             pClientData->szHost, WSAGETASYNCERROR(lParam),
  1159.                             SockerrToString(WSAGETASYNCERROR(lParam)));
  1160.                 }
  1161.             }
  1162.             break;
  1163.                         
  1164.         case WM_TIMER:
  1165.             {
  1166.                 DWORD startTicks = GetTickCount();
  1167.  
  1168.                 if (pClientData == NULL) {
  1169.                      break;
  1170.                 }
  1171.  
  1172.                 /* If there are no buffers pending, advance the timeout
  1173.                    counter.  When it reaches TIMEOUT_CONNECTION, close the
  1174.                    connection. */
  1175.             
  1176.                 if (wParam == FRAME_TIMER_ID && !broadcasting && 
  1177.                     pClientData->timeout >= 0 && outputPending == 0) {
  1178.                     if ((pClientData->timeout++) >= TIMEOUT_CONNECTION) {
  1179.                         FORWARD_WM_MDIDESTROY(hwndMDIClient, hwnd, SendMessage);
  1180.                         return 0;
  1181.                     }
  1182.                     if (pClientData->timeout == 5) {
  1183.                         if (!IsIconic(hwnd)) {
  1184.                             pClientData->cbReceived = 0;
  1185.                             pClientData->state = Idle;
  1186. if (pClientData->face_stat == -1) {
  1187.     pClientData->face_stat = FSinit;    
  1188. }                            
  1189. #ifdef SHOW_STATE                            
  1190.                             InvalidateRect(hwnd, NULL, TRUE);
  1191.                             UpdateWindow(hwnd);
  1192. #endif             
  1193.                         }
  1194.                     }
  1195.                 }
  1196.                 
  1197.                 /* If a broadcast is underway and the site has requested
  1198.                    to unsubscribe, close the connection after a decent
  1199.                    interval has elapsed to avoid toggling due to multiple
  1200.                    packets. */
  1201.                    
  1202.                 if (wParam == FRAME_TIMER_ID && broadcasting &&
  1203.                     pClientData->broadcastEnd &&
  1204.                     ((GetTickCount() - pClientData->broadcastBeginTime) >
  1205.                      (BroadcastUnsubscribe * 1000L))) {
  1206.                     FORWARD_WM_MDIDESTROY(hwndMDIClient, hwnd, SendMessage);
  1207.                     return 0;
  1208.                 }    
  1209.                  
  1210.                 /* Cadence timer indicating it's time to send the
  1211.                    next block of a sound file.  Read it in and send
  1212.                    it on its way. */
  1213.             
  1214.                 if (wParam == 2 && pClientData->hFile != HFILE_ERROR ||
  1215.                                    pClientData->mmioHandle != NULL) {
  1216.                         long et;
  1217.                         UINT bread = 0;
  1218.                         
  1219.                         if (pClientData->modemConnection) {
  1220.                             int err;
  1221.                             COMSTAT cs;
  1222.                             
  1223.                             err = GetCommError(modemHandle, &cs);
  1224.                             if (cs.cbOutQue > 1000) {
  1225.                                 /* If modem connection and modem's backed up
  1226.                                    with output, spin until it goes idle. */
  1227.                                 SetTimer(hwnd, 2, 10, NULL);
  1228.                                 break;
  1229.                             }
  1230.                         }
  1231.                         if (pClientData->mmioHandle != NULL) {
  1232.                             //    Queue next packet from .WAV input file
  1233.                             if (!pClientData->quitSoundFile) {
  1234.                                 bread = readWaveNext(hwnd, pClientData);
  1235.                             }
  1236.                             if (bread == 0) {
  1237.                                 readWaveTerm(pClientData);
  1238.                             } else {
  1239.                                 bread = (UINT) ((bread * 8000L) / 11025L);
  1240.                             } 
  1241.                         } else {
  1242.                             //    Queue next packet from .AU input file
  1243.                             if (!pClientData->quitSoundFile) {
  1244.                                 bread = _lread(pClientData->hFile,
  1245.                                         sb.buffer.buffer_val, currentInputSamples);
  1246.                             }
  1247.                             if (bread == 0) {
  1248.                                 _lclose(pClientData->hFile);
  1249.                                 pClientData->hFile = HFILE_ERROR;
  1250.                             } else {
  1251.                                 sb.buffer.buffer_len = bread;
  1252.                                 /* Since we're manufacturing our own sound buffer
  1253.                                    in place rather than calling CreateSoundBuffer(),
  1254.                                    we need to apply whatever compression is requested
  1255.                                    here before shipping the buffer. */
  1256.                                 if (compression) {
  1257.                                     compress2X(&sb);
  1258.                                 }
  1259.                                 if (gsmcompress) {
  1260.                                     gsmcomp(&sb);
  1261.                                 }
  1262.                                 if (adpcmcompress) {
  1263.                                     adpcmcomp(&sb);
  1264.                                 }
  1265.                                 if (lpccompress) {
  1266.                                     lpccomp(&sb);
  1267.                                 }
  1268.                                 shipSoundBuffer(hwnd, pClientData);
  1269.                             }
  1270.                         }        
  1271.  
  1272.                         if (bread == 0) {
  1273.                             KillTimer(hwnd, 2);
  1274.                             pClientData->state = pClientData->wantsInput ? SendingLiveAudio : Idle;
  1275.                             DragAcceptFiles(hwnd, TRUE);
  1276. #ifdef SHOW_STATE                            
  1277.                             InvalidateRect(hwnd, NULL, TRUE);
  1278.                             UpdateWindow(hwnd);
  1279. #endif                            
  1280.                             return 0;
  1281.                         }
  1282.                         pClientData->cbSent += bread;
  1283. #ifdef SHOW_STATE
  1284.                         InvalidateRect(hwnd, NULL, TRUE);
  1285.                         UpdateWindow(hwnd);
  1286. #endif                        
  1287.  
  1288.                         // If window isn't immortal, reset the timeout
  1289.                         if (pClientData->timeout > 0) {
  1290.                             pClientData->timeout = 0;
  1291.                         }
  1292.             
  1293.                         /* The following code is needed because when we're reading
  1294.                            sound from a file, as opposed to receiving it in real
  1295.                            time from the CODEC, we must meter out the samples
  1296.                            at the rate they will actually be played by the destination
  1297.                            machine.  For 8000 samples per second, this amounts
  1298.                            to 125 microseconds per sample, minus the time we spent
  1299.                            compressing the data (which is substantial for GSM) and
  1300.                            a fudge factor, kOverhead, which accounts for the time
  1301.                            spent in executing the delay itself and getting control
  1302.                            back after it's done.  If sound files pause periodically
  1303.                            (when the sending machine isn't loaded), you may need
  1304.                            to reduce the delay parameters.  If they're too low,
  1305.                            however, data will be lost when sending long sound files. */
  1306.             
  1307. #define kOverhead 25000
  1308.                         et = ((bread * 125L) - kOverhead) -
  1309.                             ((GetTickCount() - startTicks) * 1000);
  1310.                         if (et <= 0) {
  1311.                             et = 10;
  1312.                         }
  1313.                         SetTimer(hwnd, 2, (UINT) (et / 1000), NULL);
  1314. #ifdef DBT            
  1315. if (!IsIconic(hwnd)) {
  1316.     HDC hdc = GetDC(hwnd);
  1317.                             
  1318.     WinPrintf(hdc, 6, 1, "Timer reset to %d ms.", (UINT) (et / 1000));
  1319.     ReleaseDC(hwnd, hdc);        
  1320. }
  1321. #endif            
  1322.                 }
  1323.                 
  1324.                 /*    Timer indicating a periodic PGP poll is underway.
  1325.                        If PGP has finished writing the decoded session key
  1326.                        file, read it into the connection structure and put
  1327.                        it into effect, then sweep up after PGP.  */
  1328.                        
  1329.                 if (wParam == 3) {
  1330.                     HFILE kfile = _lopen(pClientData->pgpFileName,
  1331.                                         READ_WRITE | OF_SHARE_EXCLUSIVE);
  1332.                     
  1333.                     if (kfile == HFILE_ERROR) {
  1334.                         //    Still not done.  Reset the timer
  1335.                         SetTimer(hwnd, 3, 1000, NULL);
  1336.                     } else {
  1337.                         if (_lread(kfile, pClientData->pgpkey, 17) == 17) {
  1338.                             char yfn[MAX_PATH];
  1339.                             int i;
  1340.                             unsigned char ow[16];
  1341.                             
  1342.                             pClientData->pgpkey[0] = TRUE;
  1343.                             
  1344.                             //    Overwrite the session key on disc
  1345.                             
  1346.                             _llseek(kfile, 0L, 0);
  1347.                             for (i = 0; i < 16; i++) {
  1348.                                 ow[i] = 0xFF;
  1349.                             }
  1350.                             _lwrite(kfile, ow, 16);
  1351.                             _llseek(kfile, 0L, 0);
  1352.                             for (i = 0; i < 16; i++) {
  1353.                                 ow[i] = 0;
  1354.                             }
  1355.                             _lwrite(kfile, ow, 16);
  1356.                             
  1357.                             _lclose(kfile);
  1358.                             _fstrcpy(yfn, pClientData->pgpFileName);
  1359.                             _unlink(yfn);
  1360.                             _fstrcat(yfn, ".TMP");
  1361.                             _unlink(yfn);
  1362.                             pClientData->pgpFileName[0] = 0;
  1363.                             KillTimer(hwnd, 3); 
  1364.                         } else {
  1365.                             pClientData->pgpkey[0] = FALSE;
  1366.                             SetTimer(hwnd, 3, 1000, NULL);
  1367.                             _lclose(kfile);
  1368.                         }
  1369.                     }
  1370.                 }
  1371.                 
  1372.                 /*    Timer indicating a periodic PGP poll is underway.
  1373.                        If PGP has finished writing the encoded session key
  1374.                        file, read it into the connection structure and put
  1375.                        it into effect, then sweep up after PGP.  */
  1376.                        
  1377.                 if (wParam == 4) {
  1378.                     HFILE kfile = _lopen(pClientData->opgpFileName,
  1379.                                     READ | OF_SHARE_EXCLUSIVE);
  1380.                     
  1381.                     if (kfile == HFILE_ERROR) {
  1382.                         //    Still not done.  Reset the timer
  1383.                         SetTimer(hwnd, 4, 1000, NULL);
  1384.                     } else {
  1385.                         int len;
  1386.                         
  1387.                         if ((len = _lread(kfile, ebuf.buffer.buffer_val, BUFL)) > 0) {
  1388.                             int i;
  1389.                             char yfn[MAX_PATH];
  1390.                             
  1391.                             ebuf.buffer.buffer_len = len;
  1392.                             pClientData->opgpkey[0] = TRUE;        // Activate outbound PGP key
  1393.                             ebuf.compression = fKeyPGP;
  1394.                             {
  1395.                                 char gh[MAX_HOST];
  1396.                                 
  1397.                                 gethostname(gh, sizeof gh);
  1398.                                 if (strlen(gh) > ((sizeof ebuf.sendinghost) - 1)) {
  1399.                                     gh[(sizeof ebuf.sendinghost) - 1] = 0;
  1400.                                 }
  1401.                                 strcpy(ebuf.sendinghost, gh);
  1402.                             }
  1403.                             revlong(&ebuf.compression);
  1404.                             revlong(&ebuf.buffer.buffer_len);
  1405.                             
  1406.                             for (i = 0; i < 3; i++) {
  1407.                                 if (writeOutput(pClientData, (LPSTR) &ebuf,
  1408.                                         (int) ((sizeof(struct soundbuf) - BUFL) +
  1409.                                         len)) < 0) {
  1410.                                     break;
  1411.                                 }
  1412.                             }
  1413.                             _lclose(kfile);
  1414.                             
  1415.                             _fstrcpy(yfn, pClientData->opgpFileName);
  1416.                             _unlink(yfn);
  1417.                             yfn[_fstrlen(yfn) - 3] = 0;
  1418.                             _fstrcat(yfn, "TMP");
  1419.                             
  1420.                             //    Overwrite the session key on disc
  1421.                             
  1422.                             kfile = _lopen(yfn, READ_WRITE | OF_SHARE_EXCLUSIVE);
  1423.                             if (kfile != HFILE_ERROR) {
  1424.                                 int i;
  1425.                                 unsigned char ow[16];
  1426.                                 
  1427.                                 for (i = 0; i < 16; i++) {
  1428.                                     ow[i] = 0xFF;
  1429.                                 }
  1430.                                 _lwrite(kfile, ow, 16);
  1431.                                 _llseek(kfile, 0L, 0);
  1432.                                 for (i = 0; i < 16; i++) {
  1433.                                     ow[i] = 0;
  1434.                                 }
  1435.                                 _lwrite(kfile, ow, 16);
  1436.                                 _lclose(kfile);
  1437.                             }
  1438.                             _unlink(yfn);
  1439.                             pClientData->opgpFileName[0] = 0;
  1440.                             KillTimer(hwnd, 4); 
  1441.                         } else {
  1442.                             SetTimer(hwnd, 4, 1000, NULL);
  1443.                             _lclose(kfile);
  1444.                         }
  1445.                     }
  1446.                 }
  1447.                 
  1448.                 /*    Cadence timer regulating retrieval of a face
  1449.                     image from the connected host.  */
  1450.                 
  1451.                 if (wParam == 5) {
  1452.                     int makereq = FALSE;
  1453.         
  1454.                     /* If a face file transfer is in progress, request
  1455.                        the next block or, if it's time, re-issue the last
  1456.                        request if the timeout has expired. */
  1457.         
  1458.                     if (pClientData->face_stat == FSreply) {
  1459.                         makereq = TRUE;
  1460.                         pClientData->face_retry = 0;
  1461. #ifdef TRACE_FACE
  1462.                         {    char s[MAX_HOST + 80];
  1463.                         
  1464.                             wsprintf(s, "Request face data at %ld from %s\r\n",
  1465.                                 pClientData->face_address, pClientData->szHost);
  1466.                             OutputDebugString(s);
  1467.                         }
  1468. #endif                        
  1469.                     } else if (pClientData->face_stat == FSrequest) {
  1470.                         pClientData->face_timeout++;
  1471.                         if (pClientData->face_timeout >= FaceTimeout) {
  1472. #ifdef TRACE_FACE
  1473.                             {    char s[MAX_HOST + 80];
  1474.                             
  1475.                                 wsprintf(s, "Retry %d reissue face data request at %ld from %s\r\n",
  1476.                                         pClientData->face_retry, pClientData->face_address,
  1477.                                         pClientData->szHost);
  1478.                                 OutputDebugString(s);
  1479.                             }
  1480. #endif                        
  1481.                             if (pClientData->face_retry > FaceMaxRetries) {
  1482. /*                            
  1483.                                 if (pClientData->face_file != NULL) {
  1484.                                     fclose(c->face_file);
  1485.                                     c->face_file = NULL;
  1486.                                 }
  1487.                                 unlink(c->face_filename);
  1488.                                 c->face_filename[0] = 0;
  1489. */                                
  1490.                                 pClientData->face_stat = FSabandoned;
  1491.                                 if (pClientData->face_bmp != NULL) {
  1492.                                     GlobalFreePtr(pClientData->face_bmp);
  1493.                                     pClientData->face_bmp = NULL;
  1494.                                 }
  1495.                                 KillTimer(hwnd, 5);
  1496. #ifdef TRACE_FACE
  1497.                                 {    char s[MAX_HOST + 80];
  1498.                                 
  1499.                                     wsprintf(s, "Timeout, no face image available for %s\r\n",
  1500.                                             pClientData->szHost);
  1501.                                     OutputDebugString(s);
  1502.                                 }
  1503. #endif                        
  1504.                             } else {
  1505.                                 makereq = TRUE;
  1506.                                 pClientData->face_retry++;
  1507.                             }
  1508.                         }
  1509.                     } else {
  1510.                         KillTimer(hwnd, 5);            // Terminated due to data format error
  1511. #ifdef TRACE_FACE
  1512.                         OutputDebugString("Face timer shut down.\r\n");
  1513. #endif                        
  1514.                     }
  1515.         
  1516.                     if (makereq) {
  1517.                         pClientData->face_stat = FSrequest;
  1518.                         pClientData->face_timeout = 0;
  1519.                         sb.compression = htonl(fFaceData | faceRequest);
  1520.                         sb.buffer.buffer_len = htonl(pClientData->face_address);
  1521.                         if (writeOutput(pClientData, (LPSTR) &sb, sizeof(soundbuf) - BUFL) < 0) {
  1522.                              pClientData->face_stat = FSabandoned;
  1523. // *** CLEAN UP DEBRIS                                
  1524.                         }
  1525.                     }
  1526.                 }
  1527.             }
  1528.             return 0;
  1529.     }
  1530.     return DefMDIChildProc(hwnd, nMessage, wParam, lParam);
  1531. }
  1532.  
  1533.  
  1534.